#ifndef BASE_CTTCPTASKPOOL_H_
#define BASE_CTTCPTASKPOOL_H_
#include "ctTCPTask.h"
#include "ctTime.h"
#include "ct_thread.h"
#include "ct_thread_group.h"
#include "ctTCPTask.h"
#include <string>


/**
 * \brief 连接线程池类，封装了一个线程处理多个连接的线程池框架
 *
 */
class ctSyncThread;
class ctRecycleThread;
class ctTCPTask;
class ctTCPTaskPool : private ctNoncopyable
{
        public:

                /**
                 * \brief 构造函数
                 * \param maxConns 线程池并行处理有效连接的最大数量
                 * \param state 初始化的时候连接线程池的状态
                 */
                explicit ctTCPTaskPool(const int maxConn, const int state) 
                        : maxConns((maxConn==0)?1:maxConn),state(state)
                {
                        syncThread = NULL;
                        recycleThread = NULL;
                        maxThreadCount = minThreadCount;
                };

                /**
                 * \brief 析构函数，销毁一个线程池对象
                 *
                 */
                ~ctTCPTaskPool()
                {
                        final();
                }

                /**
                 * \brief 获取连接线程池当前状态
                 *
                 * \return 返回连接线程池的当前状态
                 */
                const int getState() const
                {
                        return state;
                }

                /**
                 * \brief 设置连接线程池状态
                 *
                 * \param state 设置的状态标记位
                 */
                void setState(const int state)
                {
                        this->state |= state;
                }

                /**
                 * \brief 清楚连接线程池状态
                 *
                 * \param state 清楚的状态标记位
                 */
                void clearState(const int state)
                {
                        this->state &= ~state;
                }

                const int getSize();
                inline const int getMaxConns() const { return maxConns; }
                bool addVerify(ctTCPTask *task);
                void addSync(ctTCPTask *task);
                bool addOkay(ctTCPTask *task);
                void addRecycle(ctTCPTask *task);
                bool init();
                void final();

        private:

                const int maxConns;			/**< 线程池并行处理连接的最大数量 */
                static const int maxVerifyThreads = 4;	/**< 最大验证线程数量 */
                static const int minThreadCount = 1;	/**< 线程池中同时存在主处理线程的最少个数 */
                int maxThreadCount;			/**< 线程池中同时存在主处理线程的最大个数 */

                ctThreadGroup verifyThreads;		/**< 验证线程，可以有多个 */

                ctSyncThread *syncThread;		/**< 等待同步线程 */

                ctThreadGroup okayThreads;		/**< 处理主线程，多个 */

                ctRecycleThread *recycleThread;		/**< 连接回收线程 */

                int state;				/**< 连接池状态 */
};

#endif //BASE_CTTCPTASKPOOL_H_

